ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஃபங்ஷன் கோரூட்டின்: கூட்டுறவு பல்பணி செயலாக்கம்

ஜாவாஸ்கிரிப்ட், பாரம்பரியமாக ஒரு ஒற்றை-திரிக்கப்பட்ட மொழியாக அறியப்படுகிறது, இது சிக்கலான ஒத்திசைவற்ற செயல்பாடுகளைக் கையாளும்போதும் மற்றும் ஒத்திசைவை நிர்வகிக்கும்போதும் சவால்களை எதிர்கொள்கிறது. ஈவண்ட் லூப் மற்றும் பிராமிஸ்கள் மற்றும் async/await போன்ற ஒத்திசைவற்ற புரோகிராமிங் மாதிரிகள் சக்திவாய்ந்த கருவிகளை வழங்கினாலும், சில சூழ்நிலைகளுக்குத் தேவையான நுணுக்கமான கட்டுப்பாட்டை அவை எப்போதும் வழங்குவதில்லை. இங்குதான் ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஃபங்ஷன்களைப் பயன்படுத்தி செயல்படுத்தப்படும் கோரூட்டின்கள் வருகின்றன. கோரூட்டின்கள் கூட்டுறவு பல்பணியின் ஒரு வடிவத்தை அடைய நம்மை அனுமதிக்கின்றன, இது ஒத்திசைவற்ற குறியீட்டை திறமையாக நிர்வகிக்க உதவுகிறது மற்றும் செயல்திறனை மேம்படுத்தக்கூடும்.

கோரூட்டின்கள் மற்றும் கூட்டுறவு பல்பணியைப் புரிந்துகொள்ளுதல்

ஜாவாஸ்கிரிப்ட் செயலாக்கத்திற்குள் செல்வதற்கு முன், கோரூட்டின்கள் மற்றும் கூட்டுறவு பல்பணி என்றால் என்ன என்பதை வரையறுப்போம்:

• கோரூட்டின்: ஒரு கோரூட்டின் என்பது ஒரு துணைநிரலின் (அல்லது செயல்பாடு) பொதுமைப்படுத்தலாகும். துணைநிரல்கள் ஒரு கட்டத்தில் உள்ளிடப்பட்டு மற்றொரு கட்டத்தில் வெளியேறும். கோரூட்டின்கள் பல வெவ்வேறு கட்டங்களில் உள்ளிடப்படலாம், வெளியேறலாம் மற்றும் மீண்டும் தொடரலாம். இந்த "மீண்டும் தொடங்கக்கூடிய" செயலாக்கம் முக்கியமானது.
• கூட்டுறவு பல்பணி: இது ஒரு வகையான பல்பணி ஆகும், இதில் பணிகள் தன்னிச்சையாக ஒன்றையொன்று கட்டுப்பாட்டை விட்டுக்கொடுக்கின்றன. பல இயக்க முறைமைகளில் பயன்படுத்தப்படும் முன்கூட்டிய பல்பணியைப் போலன்றி, அங்கு OS ஷெட்யூலர் பணிகளை வலுக்கட்டாயமாக குறுக்கிடுகிறது, கூட்டுறவு பல்பணி ஒவ்வொரு பணியும் வெளிப்படையாக கட்டுப்பாட்டை விட்டுக்கொடுப்பதை நம்பியுள்ளது, மற்ற பணிகளை இயக்க அனுமதிக்கிறது. ஒரு பணி கட்டுப்பாட்டை விட்டுக்கொடுக்கவில்லை என்றால், கணினி செயலிழந்து போகலாம்.

சுருக்கமாக, கோரூட்டின்கள் தொடர்ச்சியாகத் தோன்றும் குறியீட்டை எழுத உங்களை அனுமதிக்கின்றன, ஆனால் செயலாக்கத்தை இடைநிறுத்தி பின்னர் மீண்டும் தொடங்க முடியும், இது ஒத்திசைவற்ற செயல்பாடுகளை மிகவும் ஒழுங்கமைக்கப்பட்ட மற்றும் நிர்வகிக்கக்கூடிய வழியில் கையாள ஏற்றதாக அமைகிறது.

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஃபங்ஷன்கள்: கோரூட்டின்களுக்கான அடித்தளம்

ECMAScript 2015 (ES6) இல் அறிமுகப்படுத்தப்பட்ட ஜாவாஸ்கிரிப்ட்டின் ஜெனரேட்டர் ஃபங்ஷன்கள், கோரூட்டின்களை செயல்படுத்தும் பொறிமுறையை வழங்குகின்றன. ஜெனரேட்டர் ஃபங்ஷன்கள் சிறப்பு செயல்பாடுகள் ஆகும், அவை செயலாக்கத்தின் போது இடைநிறுத்தப்பட்டு மீண்டும் தொடங்கப்படலாம். அவை இதை yield என்ற முக்கிய சொல்லைப் பயன்படுத்தி அடைகின்றன.

ஒரு ஜெனரேட்டர் ஃபங்ஷனின் அடிப்படை உதாரணம் இதோ:

            function* myGenerator() {
  console.log("First");
  yield 1;
  console.log("Second");
  yield 2;
  console.log("Third");
  return 3;
}

const iterator = myGenerator();

console.log(iterator.next()); // Output: First, { value: 1, done: false }
console.log(iterator.next()); // Output: Second, { value: 2, done: false }
console.log(iterator.next()); // Output: Third, { value: 3, done: true }

            

              
                Copy
              
            
          

இந்த உதாரணத்திலிருந்து முக்கிய குறிப்புகள்:

• ஜெனரேட்டர் ஃபங்ஷன்கள் function* தொடரியலைப் பயன்படுத்தி வரையறுக்கப்படுகின்றன.
• yield முக்கிய சொல் ஃபங்ஷனின் செயலாக்கத்தை இடைநிறுத்தி ஒரு மதிப்பைத் திருப்புகிறது.
• ஒரு ஜெனரேட்டர் ஃபங்ஷனை அழைப்பது உடனடியாக குறியீட்டை இயக்காது; அது ஒரு இட்டரேட்டர் ஆப்ஜெக்டைத் திருப்புகிறது.
• iterator.next() முறை அடுத்த yield அல்லது return கூற்று வரை ஃபங்ஷனின் செயலாக்கத்தை மீண்டும் தொடங்குகிறது. அது value (yield செய்யப்பட்ட அல்லது திருப்பப்பட்ட மதிப்பு) மற்றும் done (ஃபங்ஷன் முடிந்துவிட்டதா என்பதைக் குறிக்கும் ஒரு பூலியன்) கொண்ட ஒரு ஆப்ஜெக்டைத் திருப்புகிறது.

ஜெனரேட்டர் ஃபங்ஷன்களைக் கொண்டு கூட்டுறவு பல்பணியை செயல்படுத்துதல்

இப்போது, ஜெனரேட்டர் ஃபங்ஷன்களைப் பயன்படுத்தி கூட்டுறவு பல்பணியை எவ்வாறு செயல்படுத்தலாம் என்பதைப் பார்ப்போம். முக்கிய யோசனை என்னவென்றால், கோரூட்டின்களின் வரிசையை நிர்வகித்து அவற்றை ஒவ்வொன்றாக இயக்கும் ஒரு ஷெட்யூலரை உருவாக்குவது, ஒவ்வொரு கோரூட்டினையும் ஷெட்யூலருக்கு கட்டுப்பாட்டைத் திருப்பித் தருவதற்கு முன் ஒரு குறுகிய காலத்திற்கு இயக்க அனுமதிப்பது.

இதோ ஒரு எளிமையான உதாரணம்:

            class Scheduler {
  constructor() {
    this.tasks = [];
  }

  addTask(task) {
    this.tasks.push(task);
  }

  run() {
    while (this.tasks.length > 0) {
      const task = this.tasks.shift();
      const result = task.next();

      if (!result.done) {
        this.tasks.push(task); // Re-add the task to the queue if it's not done
      }
    }
  }
}

// Example tasks
function* task1() {
  console.log("Task 1: Starting");
  yield;
  console.log("Task 1: Continuing");
  yield;
  console.log("Task 1: Finishing");
}

function* task2() {
  console.log("Task 2: Starting");
  yield;
  console.log("Task 2: Continuing");
  yield;
  console.log("Task 2: Finishing");
}

// Create a scheduler and add tasks
const scheduler = new Scheduler();
scheduler.addTask(task1());
scheduler.addTask(task2());

// Run the scheduler
scheduler.run();

// Expected output (order may vary slightly due to queueing):
// Task 1: Starting
// Task 2: Starting
// Task 1: Continuing
// Task 2: Continuing
// Task 1: Finishing
// Task 2: Finishing

            

              
                Copy
              
            
          

இந்த உதாரணத்தில்:

• Scheduler கிளாஸ் பணிகளின் (கோரூட்டின்கள்) ஒரு வரிசையை நிர்வகிக்கிறது.
• addTask முறை வரிசையில் புதிய பணிகளைச் சேர்க்கிறது.
• run முறை வரிசையின் வழியாகச் சென்று, ஒவ்வொரு பணியின் next() முறையை இயக்குகிறது.
• ஒரு பணி முடியவில்லை என்றால் (result.done என்பது false), அது வரிசையின் முடிவில் மீண்டும் சேர்க்கப்படுகிறது, மற்ற பணிகளை இயக்க அனுமதிக்கிறது.

ஒத்திசைவற்ற செயல்பாடுகளை ஒருங்கிணைத்தல்

கோரூட்டின்களின் உண்மையான சக்தி, அவற்றை ஒத்திசைவற்ற செயல்பாடுகளுடன் ஒருங்கிணைக்கும்போது வெளிப்படுகிறது. ஒத்திசைவற்ற பணிகளை மிகவும் திறம்பட கையாள, ஜெனரேட்டர் ஃபங்ஷன்களுக்குள் பிராமிஸ்கள் மற்றும் async/await ஐப் பயன்படுத்தலாம்.

இதை விளக்கும் ஒரு உதாரணம் இதோ:

            function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

function* asyncTask(id) {
  console.log(`Task ${id}: Starting`);
  yield delay(1000); // Simulate an asynchronous operation
  console.log(`Task ${id}: After 1 second`);
  yield delay(500); // Simulate another asynchronous operation
  console.log(`Task ${id}: Finishing`);
}

class AsyncScheduler {
  constructor() {
    this.tasks = [];
  }

  addTask(task) {
    this.tasks.push(task);
  }

  async run() {
    while (this.tasks.length > 0) {
      const task = this.tasks.shift();
      const result = task.next();

      if (result.value instanceof Promise) {
        await result.value; // Wait for the Promise to resolve
      }

      if (!result.done) {
        this.tasks.push(task);
      }
    }
  }
}

const asyncScheduler = new AsyncScheduler();
asyncScheduler.addTask(asyncTask(1));
asyncScheduler.addTask(asyncTask(2));

asyncScheduler.run();

// Possible Output (order can vary slightly due to asynchronous nature):
// Task 1: Starting
// Task 2: Starting
// Task 1: After 1 second
// Task 2: After 1 second
// Task 1: Finishing
// Task 2: Finishing

            

              
                Copy
              
            
          

இந்த உதாரணத்தில்:

• delay ஃபங்ஷன் ஒரு குறிப்பிட்ட நேரத்திற்குப் பிறகு தீர்க்கப்படும் ஒரு பிராமிஸைத் திருப்புகிறது.
• asyncTask ஜெனரேட்டர் ஃபங்ஷன் yield delay(ms) ஐப் பயன்படுத்தி செயலாக்கத்தை இடைநிறுத்தி பிராமிஸ் தீர்க்கப்படும் வரை காத்திருக்கிறது.
• AsyncScheduler இன் run முறை இப்போது result.value ஒரு பிராமிஸா என்பதை சரிபார்க்கிறது. அப்படியிருந்தால், அது பிராமிஸ் தீர்க்கப்படும் வரை காத்திருக்க await ஐப் பயன்படுத்துகிறது, பிறகு தொடர்கிறது.

ஜெனரேட்டர் ஃபங்ஷன்களுடன் கோரூட்டின்களைப் பயன்படுத்துவதன் நன்மைகள்

ஜெனரேட்டர் ஃபங்ஷன்களுடன் கோரூட்டின்களைப் பயன்படுத்துவது பல சாத்தியமான நன்மைகளை வழங்குகிறது:

• மேம்பட்ட குறியீடு வாசிப்புத்திறன்: கோரூட்டின்கள், ஆழமாகப் பதிக்கப்பட்ட கால்பேக்குகள் அல்லது சிக்கலான பிராமிஸ் சங்கிலிகளுடன் ஒப்பிடும்போது, தொடர்ச்சியாகவும் எளிதாகவும் புரிந்துகொள்ளக்கூடிய ஒத்திசைவற்ற குறியீட்டை எழுத உங்களை அனுமதிக்கின்றன.
• எளிமைப்படுத்தப்பட்ட பிழை கையாளுதல்: கோரூட்டினுக்குள் try/catch பிளாக்குகளைப் பயன்படுத்துவதன் மூலம் பிழை கையாளுதலை எளிதாக்கலாம், இது ஒத்திசைவற்ற செயல்பாடுகளின் போது ஏற்படும் பிழைகளைப் பிடித்து கையாளுவதை எளிதாக்குகிறது.
• ஒத்திசைவு மீது சிறந்த கட்டுப்பாடு: கோரூட்டின் அடிப்படையிலான கூட்டுறவு பல்பணி பாரம்பரிய ஒத்திசைவற்ற முறைகளைக் காட்டிலும் ஒத்திசைவு மீது அதிக நுணுக்கமான கட்டுப்பாட்டை வழங்குகிறது. பணிகள் எப்போது விட்டுக்கொடுக்க வேண்டும் மற்றும் மீண்டும் தொடங்க வேண்டும் என்பதை நீங்கள் வெளிப்படையாகக் கட்டுப்படுத்தலாம், இது சிறந்த வள மேலாண்மைக்கு வழிவகுக்கிறது.
• சாத்தியமான செயல்திறன் மேம்பாடுகள்: சில சூழ்நிலைகளில், கோரூட்டின்கள் த்ரெட்களை உருவாக்குதல் மற்றும் நிர்வகித்தலுடன் தொடர்புடைய மேல்நிலையச் செலவைக் குறைப்பதன் மூலம் செயல்திறன் மேம்பாடுகளை வழங்க முடியும் (ஏனெனில் ஜாவாஸ்கிரிப்ட் ஒற்றை-திரிக்கப்பட்டதாகவே உள்ளது). கூட்டுறவு இயல்பு, முன்கூட்டிய பல்பணியின் சூழல் மாற்ற மேல்நிலையச் செலவைத் தவிர்க்கிறது.
• எளிதான சோதனை: கால்பேக்குகளை நம்பியிருக்கும் ஒத்திசைவற்ற குறியீட்டை விட கோரூட்டின்களைச் சோதிப்பது எளிதாக இருக்கும், ஏனெனில் நீங்கள் செயலாக்க ஓட்டத்தைக் கட்டுப்படுத்தலாம் மற்றும் ஒத்திசைவற்ற சார்புகளை எளிதாகப் போலியாக மாற்றலாம்.

சாத்தியமான குறைபாடுகள் மற்றும் கருத்தாய்வுகள்

கோரூட்டின்கள் நன்மைகளை வழங்கினாலும், அவற்றின் சாத்தியமான குறைபாடுகளைப் பற்றி அறிந்திருப்பது முக்கியம்:

• சிக்கலான தன்மை: கோரூட்டின்கள் மற்றும் ஷெட்யூலர்களை செயல்படுத்துவது உங்கள் குறியீட்டிற்கு சிக்கலைச் சேர்க்கலாம், குறிப்பாக சிக்கலான சூழ்நிலைகளுக்கு.
• கூட்டுறவு இயல்பு: பல்பணியின் கூட்டுறவு இயல்பு என்பது ஒரு நீண்ட நேரம் இயங்கும் அல்லது தடுக்கும் கோரூட்டின் மற்ற பணிகளை இயக்க விடாமல் தடுக்கலாம், இது செயல்திறன் சிக்கல்களுக்கு அல்லது பயன்பாட்டு செயலிழப்புக்கு வழிவகுக்கும். கவனமான வடிவமைப்பு மற்றும் கண்காணிப்பு அவசியம்.
• பிழைத்திருத்த சவால்கள்: கோரூட்டின் அடிப்படையிலான குறியீட்டை பிழைத்திருத்தம் செய்வது ஒத்திசைவான குறியீட்டை பிழைத்திருத்தம் செய்வதை விட சவாலானதாக இருக்கும், ஏனெனில் செயலாக்க ஓட்டம் குறைவான நேரடியானதாக இருக்கலாம். நல்ல பதிவிடுதல் மற்றும் பிழைத்திருத்த கருவிகள் அவசியம்.
• உண்மையான இணைத்தன்மைக்கு மாற்றீடு அல்ல: ஜாவாஸ்கிரிப்ட் ஒற்றை-திரிக்கப்பட்டதாகவே உள்ளது. கோரூட்டின்கள் ஒத்திசைவை வழங்குகின்றன, உண்மையான இணைத்தன்மையை அல்ல. CPU-சார்ந்த பணிகள் இன்னும் ஈவண்ட் லூப்பைத் தடுக்கும். உண்மையான இணைத்தன்மைக்கு, வெப் வொர்க்கர்ஸைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.

கோரூட்டின்களுக்கான பயன்பாட்டு வழக்குகள்

பின்வரும் சூழ்நிலைகளில் கோரூட்டின்கள் குறிப்பாக பயனுள்ளதாக இருக்கும்:

• அனிமேஷன் மற்றும் விளையாட்டு மேம்பாடு: சிக்கலான அனிமேஷன் வரிசைகள் மற்றும் விளையாட்டு தர்க்கத்தை நிர்வகித்தல், இதற்கு குறிப்பிட்ட புள்ளிகளில் செயலாக்கத்தை இடைநிறுத்தி மீண்டும் தொடங்க வேண்டும்.
• ஒத்திசைவற்ற தரவு செயலாக்கம்: பெரிய தரவுத்தொகுப்புகளை ஒத்திசைவற்ற முறையில் செயலாக்குதல், பிரதான திரியைத் தடுக்காமல் இருக்க அவ்வப்போது கட்டுப்பாட்டை விட்டுக்கொடுக்க உங்களை அனுமதிக்கிறது. எடுத்துக்காட்டுகளில் ஒரு வலை உலாவியில் பெரிய CSV கோப்புகளைப் பாகுபடுத்துதல், அல்லது ஒரு IoT பயன்பாட்டில் ஒரு சென்சாரிலிருந்து வரும் ஸ்ட்ரீமிங் தரவைச் செயலாக்குதல் ஆகியவை அடங்கும்.
• பயனர் இடைமுக நிகழ்வு கையாளுதல்: படிவ சரிபார்ப்பு அல்லது தரவுப் பெறுதல் போன்ற பல ஒத்திசைவற்ற செயல்பாடுகளை உள்ளடக்கிய சிக்கலான UI தொடர்புகளை உருவாக்குதல்.
• வலை சேவையக கட்டமைப்புகள் (Node.js): சில Node.js கட்டமைப்புகள் கோரிக்கைகளை ஒரே நேரத்தில் கையாள கோரூட்டின்களைப் பயன்படுத்துகின்றன, இது சேவையகத்தின் ஒட்டுமொத்த செயல்திறனை மேம்படுத்துகிறது.
• I/O-சார்ந்த செயல்பாடுகள்: ஒத்திசைவற்ற I/O-க்கு மாற்றாக இல்லாவிட்டாலும், பல I/O செயல்பாடுகளைக் கையாளும் போது கட்டுப்பாட்டு ஓட்டத்தை நிர்வகிக்க கோரூட்டின்கள் உதவலாம்.

நிஜ உலக உதாரணங்கள்

வெவ்வேறு கண்டங்களில் உள்ள சில நிஜ உலக உதாரணங்களைக் கருத்தில் கொள்வோம்:

• இந்தியாவில் இ-காமர்ஸ்: ஒரு பண்டிகை விற்பனையின் போது ஆயிரக்கணக்கான ஒரே நேரத்திலான கோரிக்கைகளைக் கையாளும் ஒரு பெரிய இ-காமர்ஸ் தளத்தை கற்பனை செய்து பாருங்கள். கோரூட்டின்கள் தரவுத்தள இணைப்புகள் மற்றும் கட்டண நுழைவாயில்களுக்கான ஒத்திசைவற்ற அழைப்புகளை நிர்வகிக்கப் பயன்படுத்தப்படலாம், இது அதிக சுமையின் கீழும் கணினி பதிலளிக்கக்கூடியதாக இருப்பதை உறுதி செய்கிறது. கூட்டுறவு இயல்பு, ஆர்டர் செய்தல் போன்ற முக்கியமான செயல்பாடுகளுக்கு முன்னுரிமை அளிக்க உதவும்.
• லண்டனில் நிதி வர்த்தகம்: லண்டனில் உள்ள ஒரு உயர்-அதிர்வெண் வர்த்தக அமைப்பில், ஒத்திசைவற்ற சந்தைத் தரவு ஊட்டங்களை நிர்வகிக்கவும், சிக்கலான அல்காரிதம்களின் அடிப்படையில் வர்த்தகங்களைச் செயல்படுத்தவும் கோரூட்டின்கள் பயன்படுத்தப்படலாம். சரியான நேரங்களில் செயலாக்கத்தை இடைநிறுத்தி மீண்டும் தொடங்கும் திறன், தாமதத்தைக் குறைக்க முக்கியமானது.
• பிரேசிலில் ஸ்மார்ட் வேளாண்மை: பிரேசிலில் உள்ள ஒரு ஸ்மார்ட் வேளாண்மை அமைப்பு, பல்வேறு சென்சார்களில் (வெப்பநிலை, ஈரப்பதம், மண் ஈரப்பதம்) இருந்து தரவைச் செயலாக்கவும், நீர்ப்பாசன அமைப்புகளைக் கட்டுப்படுத்தவும் கோரூட்டின்களைப் பயன்படுத்தலாம். இந்த அமைப்பு ஒத்திசைவற்ற தரவு ஓட்டங்களைக் கையாள வேண்டும் மற்றும் நிகழ்நேரத்தில் முடிவுகளை எடுக்க வேண்டும், இது கோரூட்டின்களை ஒரு பொருத்தமான தேர்வாக ஆக்குகிறது.
• சீனாவில் லாஜிஸ்டிக்ஸ்: சீனாவில் உள்ள ஒரு லாஜிஸ்டிக்ஸ் நிறுவனம் ஆயிரக்கணக்கான தொகுப்புகளின் ஒத்திசைவற்ற கண்காணிப்பு புதுப்பிப்புகளை நிர்வகிக்க கோரூட்டின்களைப் பயன்படுத்துகிறது. இந்த ஒத்திசைவு, வாடிக்கையாளர் எதிர்கொள்ளும் கண்காணிப்பு அமைப்புகள் எப்போதும் புதுப்பித்ததாகவும் பதிலளிக்கக்கூடியதாகவும் இருப்பதை உறுதி செய்கிறது.

முடிவுரை

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஃபங்ஷன் கோரூட்டின்கள், கூட்டுறவு பல்பணியை செயல்படுத்தவும், ஒத்திசைவற்ற குறியீட்டை மிகவும் திறம்பட நிர்வகிக்கவும் ஒரு சக்திவாய்ந்த பொறிமுறையை வழங்குகின்றன. அவை எல்லா சூழ்நிலைகளுக்கும் பொருத்தமானதாக இல்லாவிட்டாலும், குறியீடு வாசிப்புத்திறன், பிழை கையாளுதல் மற்றும் ஒத்திசைவின் மீதான கட்டுப்பாடு ஆகியவற்றின் அடிப்படையில் குறிப்பிடத்தக்க நன்மைகளை வழங்க முடியும். கோரூட்டின்களின் கொள்கைகள் மற்றும் அவற்றின் சாத்தியமான குறைபாடுகளைப் புரிந்துகொள்வதன் மூலம், டெவலப்பர்கள் தங்கள் ஜாவாஸ்கிரிப்ட் பயன்பாடுகளில் அவற்றை எப்போது, எப்படிப் பயன்படுத்துவது என்பது பற்றிய தகவலறிந்த முடிவுகளை எடுக்கலாம்.

மேலும் ஆராய

• ஜாவாஸ்கிரிப்ட் Async/Await: இது ஒரு தொடர்புடைய அம்சமாகும், இது ஒத்திசைவற்ற புரோகிராமிங்கிற்கு மிகவும் நவீனமான மற்றும் எளிமையான அணுகுமுறையை வழங்குகிறது.
• வெப் வொர்க்கர்ஸ்: ஜாவாஸ்கிரிப்ட்டில் உண்மையான இணைத்தன்மைக்கு, வெப் வொர்க்கர்ஸை ஆராயுங்கள், இது தனித்தனி திரிகளில் குறியீட்டை இயக்க உங்களை அனுமதிக்கிறது.
• நூலகங்கள் மற்றும் கட்டமைப்புகள்: ஜாவாஸ்கிரிப்ட்டில் கோரூட்டின்கள் மற்றும் ஒத்திசைவற்ற புரோகிராமிங்குடன் வேலை செய்வதற்கான உயர்-நிலை சுருக்கங்களை வழங்கும் நூலகங்கள் மற்றும் கட்டமைப்புகளை ஆராயுங்கள்.